deployments/pulumi/postgres/main.go (2)

13-17: Consider improving configuration handling.

While the current implementation works, consider these improvements:

1. Use a specific config name instead of an empty string in config.New()
2. Consider making the default namespace configurable or documented

-		conf := config.New(ctx, "")
+		conf := config.New(ctx, "postgres")

---

1-27: Consider documenting integration points and deployment requirements.

As this is part of a larger restructuring effort ("pulumi split"), it would be valuable to:

1. Document the prerequisites and deployment requirements
2. Clarify how this PostgreSQL component fits into the broader architecture
3. Consider adding comments explaining the expected configuration values

test/rolling-upgrades/generator/main.go (3)

19-19: Consider making the default image configurable

The default image URL is hardcoded. Consider moving this to a constant or environment variable for easier maintenance and flexibility across environments.

+const defaultGeneratorImage = "ghcr.io/formancehq/ledger-generator:latest"
+
 func main() {
     // ...
     if image == "" {
-        image = "ghcr.io/formancehq/ledger-generator:latest"
+        image = defaultGeneratorImage
     }

---

23-30: Enhance error handling and consider component lifecycle

While basic error handling is present, consider:

1. Adding more context to the error return
2. Explicitly handling component cleanup if needed

 _, err = pulumi_generator.NewGeneratorComponent(ctx, "generator", &pulumi_generator.GeneratorComponentArgs{
     Namespace: pulumi.String(namespace),
     LedgerURL: pulumi.String(ledgerURL),
     Image:     pulumi.String(image),
 })
 if err != nil {
-    return err
+    return fmt.Errorf("failed to create generator component: %w", err)
 }

---

1-8: Add package documentation

Consider adding a package comment explaining:

• The purpose of this generator
• Required configuration values
• Usage examples

 package main

+// Package main provides a Pulumi program for deploying and managing the ledger generator.
+//
+// Configuration:
+// - namespace: (optional) Kubernetes namespace, defaults to "default"
+// - image: (optional) Generator image, defaults to ghcr.io/formancehq/ledger-generator:latest
+// - ledger-url: (required) URL of the ledger service
+
 import (

deployments/pulumi/ledger/Earthfile (1)

28-38: Consider adjusting linting configuration

Two potential improvements for the lint target:

1. The --fix flag automatically modifies code, which might not be ideal in CI pipelines. Consider running without --fix in CI and only using it locally.
2. The 5-minute timeout might be insufficient for larger codebases. Consider increasing it or making it configurable.

-    RUN golangci-lint run --fix --build-tags it --timeout 5m
+    ARG LINT_TIMEOUT="5m"
+    ARG CI="false"
+    IF [ "$CI" = "true" ]
+        RUN golangci-lint run --build-tags it --timeout=$LINT_TIMEOUT
+    ELSE
+        RUN golangci-lint run --fix --build-tags it --timeout=$LINT_TIMEOUT
+    END

deployments/pulumi/postgres/Earthfile (2)

12-17: Enhance file copying robustness

While the basic file copying is in place, consider adding:

1. Validation for required files before proceeding
2. More specific error messages if critical files are missing
3. Consider using --if-exists flag for optional files

 sources:
     FROM core+builder-image
     WORKDIR /src
-    COPY *.go go.* Pulumi.yaml .
+    COPY main.go go.* Pulumi.yaml .
+    COPY --if-exists *.go .
     COPY --dir pkg .
+    RUN test -f main.go && test -f go.mod && test -f Pulumi.yaml
     SAVE ARTIFACT /src

---

39-41: Consider adding more pre-commit checks

The pre-commit stage could be enhanced with additional checks:

1. Unit tests
2. Security scanning
3. Dependency vulnerability checks

 pre-commit:
     BUILD +tidy
     BUILD +lint
+    BUILD +test
+    BUILD +security-scan

test/rolling-upgrades/generator/Earthfile (2)

12-22: Consider more specific source copying strategy.

The current source copying strategy (COPY ../../..+sources/src /src) is quite broad. Consider being more specific about which files are needed to reduce build context size and improve build performance.

-    COPY ../../..+sources/src /src
+    COPY ../../..+sources/src/test/rolling-upgrades/generator /src/test/rolling-upgrades/generator
+    COPY ../../..+sources/src/go.mod /src/
+    COPY ../../..+sources/src/go.sum /src/

---

43-45: Consider adding more pre-commit checks.

The pre-commit target could benefit from additional checks such as:

• Unit tests
• Security scanning
• Generated code verification

 pre-commit:
     BUILD +tidy
     BUILD +lint
+    BUILD +test
+    BUILD +security-scan
+    BUILD +verify-generated

deployments/pulumi/ledger/main.go (2)

11-14: Consider adding explicit error handling for the required PostgreSQL URI.

While Require() will panic if the value is missing, consider using RequireSecret() if the URI contains sensitive information, or implement explicit error handling for better operational control.

-		postgresURI := conf.Require("postgres.uri")
+		postgresURI, err := conf.TrySecret("postgres.uri")
+		if err != nil {
+			return fmt.Errorf("postgres URI is required: %w", err)
+		}

---

41-51: Add context to component initialization error.

While the error is captured, adding context would help with debugging deployment issues.

-		_, err = pulumi_ledger.NewLedgerComponent(ctx, "ledger", &pulumi_ledger.LedgerComponentArgs{
+		_, err = pulumi_ledger.NewLedgerComponent(ctx, "ledger", &pulumi_ledger.LedgerComponentArgs{
			// ... existing args ...
		})
+		if err != nil {
+			return fmt.Errorf("failed to create ledger component: %w", err)
+		}

test/rolling-upgrades/Earthfile (3)

59-65: Document the CLUSTER_NAME parameter

The requirements target consolidates multiple build steps effectively. However, consider adding a comment to document the purpose and format of the CLUSTER_NAME parameter, as it's used across multiple targets.

+# CLUSTER_NAME: Unique identifier for the test cluster (default: test-rolling-upgrades)
+# Used across multiple targets for consistent resource naming
 requirements:
     ARG CLUSTER_NAME=test-rolling-upgrades

---

103-106: Consider parameterizing image references

The test command uses hardcoded image references with the cluster name. Consider extracting these as arguments for better reusability and maintainability.

+ARG TEST_IMAGE_REPO=ghcr.io/formancehq/ledger-generator
 go test \
-    --test-image ghcr.io/formancehq/ledger-generator:$CLUSTER_NAME-rolling-upgrade-test \
+    --test-image $TEST_IMAGE_REPO:$CLUSTER_NAME-rolling-upgrade-test \
     --latest-version $CLUSTER_NAME-main \
     --actual-version $CLUSTER_NAME-current \
     --stack $CLUSTER_NAME-rolling-upgrade-test \

---

Line range hint 1-130: Document the rolling upgrade test strategy

Consider adding a README.md in the test/rolling-upgrades directory to document:

• The purpose and strategy of rolling upgrade tests
• The relationship between Pulumi configurations and these tests
• The test infrastructure setup and requirements
• Common troubleshooting steps

This documentation would be valuable for maintaining and extending the test infrastructure as the Pulumi split evolves.

deployments/pulumi/postgres/pkg/component.go (8)

9-13: Add GoDoc comment to the exported type PostgresComponent

The exported type PostgresComponent should have a documentation comment to improve code readability and maintainability.

---

15-17: Add GoDoc comment to the exported type PostgresComponentArgs

The exported type PostgresComponentArgs should have a documentation comment to improve code readability and maintainability.

---

19-19: Add GoDoc comment to the exported function NewPostgresComponent

The exported function NewPostgresComponent should have a documentation comment to improve code readability and maintainability.

---

23-24: Wrap error with context when returning

To provide more context for debugging, wrap the error with additional information.

-return nil, err
+return nil, fmt.Errorf("registering component resource: %w", err)

---

31-31: Use unique release names to prevent conflicts

Using a hardcoded release name "postgres" may lead to conflicts if multiple instances are deployed. Consider incorporating the name parameter into the release name for uniqueness.

-rel, err := helm.NewRelease(ctx, "postgres", &helm.ReleaseArgs{
+rel, err := helm.NewRelease(ctx, name, &helm.ReleaseArgs{

---

38-38: Make database name configurable

Hardcoding the database name as "ledger" reduces flexibility. Consider allowing the database name to be specified via component arguments.

---

43-44: Consider making resource requests configurable

Hardcoding resource requests for CPU and memory reduces flexibility. Allow these values to be specified via component arguments to adapt to different deployment environments.

---

49-49: Avoid creating the default namespace unnecessarily

Creating the "default" namespace is unnecessary and may cause errors. Set CreateNamespace to false when deploying to the default namespace.

You can modify the code as follows:

+	createNamespace := pulumi.Bool(true)
+	if namespace == pulumi.String("default") {
+		createNamespace = pulumi.Bool(false)
+	}
...
-		CreateNamespace: pulumi.BoolPtr(true),
+		CreateNamespace: createNamespace,

deployments/pulumi/ledger/pkg/component.go (4)

9-16: Add GoDoc comments to exported type LedgerComponent

To improve code readability and documentation, consider adding GoDoc comments to the exported type LedgerComponent.

---

18-27: Add GoDoc comments to exported type LedgerComponentArgs

To enhance code maintainability and provide clear documentation, please add GoDoc comments to the exported type LedgerComponentArgs.

---

29-29: Add GoDoc comment to exported function NewLedgerComponent

Adding a GoDoc comment to the function NewLedgerComponent will help other developers understand its purpose and usage.

---

61-61: Consider retrieving the service port dynamically instead of hardcoding

Currently, the service port is hardcoded to 8080. If the service port changes in the Helm chart, this value may become outdated. Consider retrieving the service port dynamically to ensure consistency.

test/rolling-upgrades/generator/pkg/component.go (3)

46-46: Make the parallelism parameter configurable

The hardcoded value "30" for the -p (parallelism) parameter may limit flexibility. Consider making it configurable to accommodate different use cases.

Apply the following changes:

1. Update the GeneratorComponentArgs struct to include a new field:

 type GeneratorComponentArgs struct {
 	Namespace pulumi.StringInput
 	LedgerURL pulumi.StringInput
 	Image     pulumi.StringInput
+	Parallelism pulumi.StringInput
 }

2. Modify the generatorArgs assignment to use the new Parallelism parameter:

 generatorArgs := pulumi.StringArray{
 	args.LedgerURL,
 	pulumi.String("/examples/example1.js"),
 	pulumi.String("-p"),
-	pulumi.String("30"),
+	args.Parallelism,
 }

3. Ensure that when creating a new GeneratorComponent, you provide the Parallelism argument as needed.

---

67-67: Rename the container for clarity

The container is currently named "test". For better clarity, consider renaming it to "generator" to reflect its purpose.

Apply the following change:

 Name: pulumi.String("test"),
+// Rename "test" to "generator" for clarity
-Name: pulumi.String("test"),
+Name: pulumi.String("generator"),

---

75-79: Review the custom timeout settings

The timeouts for Create, Update, and Delete operations are all set to "10s". Depending on the environment, pod creation and deletion might take longer. Consider increasing these timeouts to avoid potential issues during resource operations.

For example, you could adjust the timeouts as follows:

 pulumi.Timeouts(&pulumi.CustomTimeouts{
-	Create: "10s",
-	Update: "10s",
-	Delete: "10s",
+	Create: "2m",
+	Update: "2m",
+	Delete: "2m",
 }),

test/rolling-upgrades/main_test.go (2)

203-213: Make the Helm chart path configurable

In the resource transform, the Helm chart path is hardcoded to "../../deployments/helm". For better flexibility and maintainability, consider making the chart path configurable.

Apply this diff to use a configuration value:

+ chartPath := config.Require(ctx, "ledger:chartPath")
pulumi.Transforms([]pulumi.ResourceTransform{
    // Update relative location of the helm chart
    func(context context.Context, args *pulumi.ResourceTransformArgs) *pulumi.ResourceTransformResult {
        if args.Type == "kubernetes:helm.sh/v3:Release" {
-           args.Props["chart"] = pulumi.String("../../deployments/helm")
+           args.Props["chart"] = pulumi.String(chartPath)
        }
        return &pulumi.ResourceTransformResult{
            Props: args.Props,
        }
    },
}),

Ensure to set the ledger:chartPath configuration before running the stack.

---

Line range hint 131-139: Use logging instead of printing directly to stdout/stderr

Currently, the function upAndPrintOutputs prints StdOut and StdErr directly using fmt.Println. Consider using the logging framework to output these messages to ensure they are captured appropriately in test logs.

Apply this diff:

if out.StdErr != "" {
-   fmt.Println(out.StdErr)
+   logging.FromContext(ctx).Error(out.StdErr)
}
...
if out.StdOut != "" {
-   fmt.Println(out.StdOut)
+   logging.FromContext(ctx).Info(out.StdOut)
}

Configuration used: CodeRabbit UI
Review profile: CHILL

#!/bin/bash
# Description: Check for PostgreSQL component definition and configuration options

# Check for the component definition
ast-grep --pattern 'type PostgresComponentArgs struct {
  $$$
}'

# Look for other usages of the component
rg -l "NewPostgresComponent" --type go

#!/bin/bash
# Check the component implementation and its configuration
ast-grep --pattern 'func NewPostgresComponent($$$) {
  $$$
}'

# Check test usage for configuration patterns
rg "NewPostgresComponent" -A 5 -B 2 test/rolling-upgrades/main_test.go

#!/bin/bash
# Check the actual component implementation for required configurations
cat deployments/pulumi/postgres/pkg/component.go

#!/bin/bash
# Description: Verify the package name in the generator/pkg directory
cat test/rolling-upgrades/generator/pkg/component.go | grep "package"

#!/bin/bash
# Check latest Earthly version from their releases
curl -s https://api.github.com/repos/earthly/earthly/releases/latest | jq -r '.tag_name'

#!/bin/bash
# Let's check if there are any other Earthfiles in the repository to understand the version usage pattern
fd Earthfile --type f --exec head -n 1 {}

#!/bin/bash
# Check for Pulumi configuration files in the directory
fd -t f "Pulumi.*\.yaml$" deployments/pulumi/ledger/

#!/bin/bash
# Check the content of Pulumi.yaml to understand the project configuration
cat deployments/pulumi/ledger/Pulumi.yaml

# Also check if there are any stack references in the Go files
rg "stack\." deployments/pulumi/ledger/ -A 2

-    RUN golangci-lint run --fix --build-tags it --timeout 5m
+    COPY .golangci.yml .
+    RUN golangci-lint run --build-tags it --timeout 10m

#!/bin/bash
# Description: Check if the cache directories are properly utilized in the build process

# Check for cache directories in .gitignore
echo "Verifying cache directories are properly ignored:"
rg -l "\.cache|go/pkg/mod" .gitignore

# Look for other Earthfiles using similar caching to ensure consistency
echo "Checking cache consistency across Earthfiles:"
fd Earthfile | xargs rg "CACHE.*sharing=shared.*go-mod-cache|CACHE.*sharing=shared.*go-cache|CACHE.*sharing=shared.*golangci-cache"

#!/bin/bash
# Verify the existence of the ledger package and its component definition
fd -t f "component\.go$" "deployments/pulumi/ledger/pkg"

# Check the package declaration in the component file
rg -l "package pulumi_ledger" "deployments/pulumi/ledger/pkg"

#!/bin/bash
# Let's verify the package structure and imports
cat deployments/pulumi/ledger/pkg/component.go

# Also check the main.go file to understand how the package is used
cat deployments/pulumi/ledger/main.go

#!/bin/bash
# Description: Verify the existence of source paths used in COPY commands

echo "Checking source paths..."
for path in "./generator" "deployments/pulumi/ledger" "deployments/pulumi/postgres"; do
  if fd -t d "^${path}$"; then
    echo "✓ Found: $path"
  else
    echo "✗ Missing: $path"
  fi
done

#!/bin/bash
# Description: List directories matched by the wildcard in ./deployments/pulumi/

fd --type d --max-depth 1 '.' ./deployments/pulumi/

#!/bin/bash
# Check if both directories have Earthfiles and contain pre-commit targets
echo "=== Checking ledger/Earthfile ==="
cat ./deployments/pulumi/ledger/Earthfile 2>/dev/null | grep -A 5 "pre-commit:"

echo -e "\n=== Checking postgres/Earthfile ==="
cat ./deployments/pulumi/postgres/Earthfile 2>/dev/null | grep -A 5 "pre-commit:"

tools/dataset/pkg/rds.go (1)

57-57: Specify the exact engine version

Using "16" for EngineVersion might lead to unexpected upgrades. Specify the exact minor version to ensure consistency.

Apply this diff to specify the engine version:

-        EngineVersion:      pulumi.String("16"),
+        EngineVersion:      pulumi.String("16.0"),

tools/dataset/pkg/dataset.go (1)

88-109: Ensure dependencies are correctly set for snapshot creation

The cmp.Snapshot depends on cmp.Generator, but if cmp.Generator is nil, the DependsOn option might cause issues. Adjust the resource options accordingly.

Apply this diff to conditionally set DependsOn:

     if generator != nil {
         resourceOptions = append(resourceOptions, pulumi.DependsOn([]pulumi.Resource{generator}))
+    } else {
+        // Remove DependsOn if generator is nil
+        resourceOptions = resourceOptions
     }

tools/generator/pulumi/pkg/component.go (1)

39-45: Validate required input parameters earlier

The validation for untilLogID and script should occur before registering the component resource to fail fast if inputs are invalid.

Apply this diff to move the validation before resource registration:

+    if args.UntilLogID == nil {
+        return nil, errors.New("untilLogID is required")
+    }
+
+    if args.Script == nil {
+        return nil, errors.New("script is required")
+    }
+
     err := ctx.RegisterComponentResource("Formance:Ledger:Tools:Generator", name, cmp, opts...)
     if err != nil {
         return nil, err
     }

tools/generator/pulumi/Earthfile (1)

43-45: Consider adding tests to pre-commit target

The pre-commit target currently runs tidy and lint, but it would be beneficial to also run tests to catch potential issues early.

Apply this diff to add tests to pre-commit:

pre-commit:
    BUILD +tidy
    BUILD +lint
+   BUILD +test

+test:
+   FROM +sources
+   CACHE --id go-mod-cache /go/pkg/mod
+   CACHE --id go-cache /root/.cache/go-build
+   RUN go test ./...

tools/dataset/main.go (1)

35-35: Add context to error return

The error from NewDatasetComponent is returned without context, making it harder to debug issues.

Apply this diff to wrap the error with context:

-		return err
+		return fmt.Errorf("failed to create dataset component: %w", err)

Configuration used: CodeRabbit UI
Review profile: CHILL

#!/bin/bash
# Description: Verify the type of generatorArgs in component.go

# Search for the definition of generatorArgs and check its type
ast-grep --pattern $'
func(...) {
    $$$
    generatorArgs := $*_
    $$$
}
' *.go

#!/bin/bash
# Let's try searching for generatorArgs in the specific file mentioned in the review
rg -A 5 -B 5 "generatorArgs" tools/generator/pulumi/pkg/component.go

#!/bin/bash
# Let's also check the type definition and usage context
ast-grep --pattern 'generatorArgs.ToOutput' tools/generator/pulumi/pkg/component.go

#!/bin/bash
# Let's look at the entire function context where this conversion happens
rg -A 10 -B 10 "Args:\s+generatorArgs\.ToOutput" tools/generator/pulumi/pkg/component.go

#!/bin/bash
# Let's check the definition of pulumix.Apply4Err to understand the return type
rg -A 5 "func Apply4Err" tools/generator/pulumi/pkg/pulumix/

#!/bin/bash
# Let's also check how generatorArgs is used in the rest of the function
rg -A 20 -B 10 "pulumix\.Apply4Err\(" tools/generator/pulumi/pkg/component.go

-		err = checkStack.Workspace().RemoveStack(ctx, stack.Name())
+		err = checkStack.Workspace().RemoveStack(ctx, checkStack.Name())

 import (
     pulumi_ledger "github.com/formancehq/ledger/deployments/pulumi/ledger/pkg"
     pulumi_postgres "github.com/formancehq/ledger/deployments/pulumi/postgres/pkg"
+    pulumi_generator "github.com/formancehq/ledger/tools/generator/pulumi/pkg"
     "github.com/formancehq/ledger/tools/generator/pulumi/pkg"

tools/dataset/pkg/dataset.go (4)

8-9: Consider using more descriptive import aliases

The v1 and v2 aliases could be more descriptive to improve code readability. Consider using k8score and k8smeta instead.

-	v1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/core/v1"
-	v2 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1"
+	k8score "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/core/v1"
+	k8smeta "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1"

---

14-30: Add field documentation for better code maintainability

Consider adding documentation for the struct fields to improve code maintainability and make it easier for other developers to understand the purpose of each field.

 type DatasetComponent struct {
 	pulumi.ResourceState
+	// RDS represents the RDS database component
 	RDS       *RDSComponent
+	// Ledger represents the ledger component
 	Ledger    *pulumi_ledger.LedgerComponent
+	// Generator represents the optional generator component
 	Generator pulumix.Output[*pulumi_generator.GeneratorComponent]
+	// Snapshot represents the optional RDS cluster snapshot
 	Snapshot  pulumix.Output[*rds.ClusterSnapshot]
 }

 type DatasetComponentArgs struct {
+	// Namespace is the Kubernetes namespace where components will be deployed
 	Namespace        pulumix.Input[string]
+	// RDS contains the configuration for the RDS component
 	RDS              RDSComponentArgs
+	// LedgerVersion specifies the version of the ledger to deploy
 	LedgerVersion    pulumix.Input[string]
+	// GeneratorVersion specifies the version of the generator to deploy
 	GeneratorVersion pulumix.Input[string]
+	// UntilLogID specifies the log ID to generate up to
 	UntilLogID       pulumix.Input[int]
+	// CreateSnapshot indicates whether to create an RDS snapshot
 	CreateSnapshot   pulumix.Input[bool]
+	// Script contains the generator script to execute
 	Script           pulumix.Input[string]
 }

---

84-84: Address the TODO comment about log checking

The TODO comment indicates a potential optimization to avoid unnecessary generator runs. This should be addressed to improve efficiency.

Would you like me to help implement the log checking functionality or create a GitHub issue to track this task?

---

102-118: Consider simplifying snapshot creation logic

The snapshot creation logic contains nested conditions and resource option modifications. Consider extracting this into a separate function for better readability and maintainability.

+func createClusterSnapshot(ctx *pulumi.Context, args *DatasetComponentArgs, cmp *DatasetComponent, generator *pulumi_generator.GeneratorComponent, baseResourceOptions []pulumi.ResourceOption) (*rds.ClusterSnapshot, error) {
+	if !createSnapshot {
+		return nil, nil
+	}
+
+	resourceOptions := append(baseResourceOptions, pulumi.RetainOnDelete(true))
+	if generator != nil {
+		resourceOptions = append(resourceOptions, pulumi.DependsOn([]pulumi.Resource{generator}))
+	}
+
+	return rds.NewClusterSnapshot(ctx, fmt.Sprintf("snapshot-%d", args.UntilLogID), &rds.ClusterSnapshotArgs{
+		DbClusterIdentifier:         cmp.RDS.Cluster.ClusterIdentifier,
+		DbClusterSnapshotIdentifier: pulumi.Sprintf("%s-%d", cmp.RDS.Cluster.ClusterIdentifier, args.UntilLogID),
+	},
+		resourceOptions...,
+	)
+}

Then use it in the main function:

-	cmp.Snapshot = pulumix.Apply2Err(args.CreateSnapshot, cmp.Generator, func(createSnapshot bool, generator *pulumi_generator.GeneratorComponent) (*rds.ClusterSnapshot, error) {
-		if !createSnapshot {
-			return nil, nil
-		}
-
-		resourceOptions := append(resourceOptions, pulumi.RetainOnDelete(true))
-		if generator != nil {
-			resourceOptions = append(resourceOptions, pulumi.DependsOn([]pulumi.Resource{generator}))
-		}
-
-		return rds.NewClusterSnapshot(ctx, fmt.Sprintf("snapshot-%d", args.UntilLogID), &rds.ClusterSnapshotArgs{
-			DbClusterIdentifier:         cmp.RDS.Cluster.ClusterIdentifier,
-			DbClusterSnapshotIdentifier: pulumi.Sprintf("%s-%d", cmp.RDS.Cluster.ClusterIdentifier, args.UntilLogID),
-		},
-			resourceOptions...,
-		)
-	})
+	cmp.Snapshot = pulumix.Apply2Err(args.CreateSnapshot, cmp.Generator, func(createSnapshot bool, generator *pulumi_generator.GeneratorComponent) (*rds.ClusterSnapshot, error) {
+		return createClusterSnapshot(ctx, args, cmp, generator, resourceOptions)
+	})

tools/generator/pulumi/pkg/component.go (5)

39-41: Combine Validation of Required Inputs for Clarity

Currently, the validation of args.UntilLogID and args.Script are separate. Consider combining these checks for more concise code.

Apply this diff to combine the input validations:

-if args.UntilLogID == nil {
-    return nil, errors.New("untilLogID is required")
-}
-
-if args.Script == nil {
-    return nil, errors.New("script is required")
-}
+if args.UntilLogID == nil || args.Script == nil {
+    return nil, errors.New("untilLogID and script are required")
+}

Also applies to: 43-45

---

47-53: Simplify Error Handling in ApplyErr Functions

The ApplyErr functions for untilLogID and script perform checks that could be consolidated to streamline error handling.

Consider simplifying the code as follows:

-untilLogID := pulumix.ApplyErr(args.UntilLogID, func(untilLogID int) (int, error) {
-    if untilLogID == 0 {
-        return 0, errors.New("untilLogID must be greater than 0")
-    }
-    return untilLogID, nil
-})
+untilLogID := pulumix.ApplyErr(args.UntilLogID, func(untilLogID int) (int, error) {
+    if untilLogID <= 0 {
+        return 0, errors.New("untilLogID must be greater than 0")
+    }
+    return untilLogID, nil
+})

-script := pulumix.ApplyErr(args.Script, func(script string) (string, error) {
-    if script == "" {
-        return "", errors.New("script is required")
-    }
-    return script, nil
-})
+script := args.Script

Since you've already checked for args.Script == nil, you may not need to validate if the script is empty again unless empty strings are considered invalid.

Also applies to: 55-61

---

89-92: Document the Default Value for VUs

The default value for VUs (virtual users) is set to 30. Consider documenting this default to improve code readability.

Adding a comment explaining the default value can help future maintainers understand the choice.

---

94-111: Preallocate Slice Capacity for generatorArgs

When building generatorArgs, preallocating the slice with an estimated capacity can enhance performance.

Apply this diff to preallocate the slice capacity:

 func(ledgerURL string, features map[string]string, vus, untilLogID int) ([]string, error) {
-    ret := make([]string, 0)
+    estimatedArgs := len(features)*2 + 6
+    ret := make([]string, 0, estimatedArgs)
     for key, value := range features {
         ret = append(ret, "--ledger-feature", key+"="+value)
     }
     ret = append(ret,
         ledgerURL,
         "/scripts/script.js",
         "-p", fmt.Sprint(vus),
         "--until-log-id", fmt.Sprint(untilLogID))
     return ret, nil
 },

This allocates sufficient capacity for the slice upfront, reducing the need for reallocation.

---

117-119: Remove Unnecessary Commented-Out Code

There is commented-out code for annotations. If it's not needed, consider removing it to keep the codebase clean.

Cleaning up commented code helps maintain readability.

deployments/pulumi/ledger/pkg/component.go (6)

23-23: Use 'Timeout' parameter in probe configurations

The Timeout parameter is defined in LedgerComponentArgs but is not used in the LivenessProbe and ReadinessProbe configurations. Including TimeoutSeconds allows for customizable probe timeouts, improving health check reliability.

Apply this diff to incorporate Timeout into the probes:

v3.LivenessProbeArgs{
     HttpGet: v3.HTTPGetActionArgs{
         Path: pulumi.String("/_healthcheck"),
         Port: pulumi.String("http"),
     },
+    TimeoutSeconds: args.Timeout.ToIntPtrOutput(),
},
v3.ReadinessProbeArgs{
     HttpGet: v3.HTTPGetActionArgs{
         Path: pulumi.String("/_healthcheck"),
         Port: pulumi.String("http"),
     },
+    TimeoutSeconds: args.Timeout.ToIntPtrOutput(),
},

Ensure that args.Timeout has a reasonable default value.

Also applies to: 113-124

---

135-142: Simplify boolean to string conversion for environment variables

Converting boolean values to strings for the DEBUG and EXPERIMENTAL_FEATURES environment variables can be simplified using strconv.FormatBool, enhancing readability.

Apply this diff to simplify the conversions:

+import "strconv"

v3.EnvVarArgs{
     Name: pulumi.String("DEBUG"),
-    Value: pulumix.Apply(debug, func(debug bool) string {
-        if debug {
-            return "true"
-        }
-        return "false"
-    }).Untyped().(pulumi.StringOutput),
+    Value: pulumix.Apply(debug, func(debug bool) string {
+        return strconv.FormatBool(debug)
+    }).Untyped().(pulumi.StringOutput),
},
v3.EnvVarArgs{
     Name: pulumi.String("EXPERIMENTAL_FEATURES"),
-    Value: pulumix.Apply(experimentalFeatures, func(experimentalFeatures bool) string {
-        if experimentalFeatures {
-            return "true"
-        }
-        return "false"
-    }).Untyped().(pulumi.StringOutput),
+    Value: pulumix.Apply(experimentalFeatures, func(experimentalFeatures bool) string {
+        return strconv.FormatBool(experimentalFeatures)
+    }).Untyped().(pulumi.StringOutput),
},

Remember to import "strconv" at the top of the file.

Also applies to: 145-151

---

70-75: Simplify tag defaulting logic

The logic for defaulting the tag value can be simplified using pulumix.ApplyOrDefault, improving code clarity.

Consider this simplified version:

- tag = pulumix.Apply(args.Tag, func(tag string) string {
-     if tag == "" {
-         return "latest"
-     }
-     return tag
- })
+ tag = pulumix.ApplyOrDefault(args.Tag, "latest")

This assumes that ApplyOrDefault applies the default value if args.Tag is nil or empty.

---

153-156: Add clarification for 'GRACE_PERIOD' environment variable

There's a comment referencing an article, but it's not immediately clear how GRACE_PERIOD is used by the application. Adding a brief explanation about its purpose would improve code readability.

Consider adding a comment like:

// GRACE_PERIOD sets the duration for the server to wait before shutting down to handle ongoing requests gracefully.

---

189-203: Simplify the construction of 'ServiceInternalURL'

The construction of ServiceInternalURL can be simplified by removing the unnecessary Apply since all values are readily available.

Apply this diff:

- cmp.ServiceInternalURL = pulumix.Apply(pulumi.Sprintf(
+ cmp.ServiceInternalURL = pulumi.Sprintf(
     "http://%s.%s.svc.cluster.local:%d",
     cmp.ServiceName,
     cmp.ServiceNamespace,
     cmp.ServicePort,
- ), func(url string) string {
-     return url
- })
+ )

This makes the code more concise and easier to read.

---

82-82: Define label keys as constants to avoid repetition

The label key "com.formance.stack/app" is hardcoded in multiple places. Defining it as a constant reduces the risk of typos and makes future updates easier.

Add a constant at the top of the file:

const appLabelKey = "com.formance.stack/app"

Then update the labels:

-     "com.formance.stack/app": pulumi.String("ledger"),
+     appLabelKey: pulumi.String("ledger"),

Also applies to: 95-95

Configuration used: CodeRabbit UI
Review profile: CHILL

 	cmp.Ledger, err = pulumi_ledger.NewLedgerComponent(ctx, "ledger", &pulumi_ledger.LedgerComponentArgs{
 		Timeout:         pulumi.Int(30),
 		Tag:             args.LedgerVersion,
 		ImagePullPolicy: pulumi.String("Always"),
 		PostgresURI: pulumi.Sprintf(
 			"postgres://%s:%s@%s:%d/postgres?sslmode=disable",
 			cmp.RDS.MasterUsername,
 			cmp.RDS.MasterPassword,
 			cmp.RDS.PrimaryInstance.Endpoint,
 			cmp.RDS.PrimaryInstance.Port,
 		),
 		ExperimentalFeatures: pulumi.Bool(true),
 		Namespace:            args.Namespace,
 	},
 		resourceOptions...,
 	)
+	if err != nil {
+		return nil, fmt.Errorf("creating Ledger component: %w", err)
+	}

+	import "github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
+
+	conf := config.New(ctx, "")
-	masterUsername := pulumix.Val("root")
-	masterPassword := pulumix.Val("password")
+	masterUsername := pulumix.Val(conf.Require("dbUsername"))
+	masterPassword := pulumix.Val(conf.RequireSecret("dbPassword"))

if err := ctx.RegisterResourceOutputs(cmp, pulumi.Map{
    "jobNamespace": cmp.JobNamespace,
    "jobName":      cmp.JobName,
    "jobID":        cmp.JobID,
}); err != nil {
    return nil, fmt.Errorf("registering outputs: %w", err)
}

-scriptConfigMap := pulumix.ApplyErr(script, func(script string) (*v1.ConfigMap, error) {
-    return v1.NewConfigMap(ctx, "generator-script", &v1.ConfigMapArgs{
+scriptConfigMap := pulumix.ApplyErr(script, func(script string) (*v1.ConfigMap, error) {
+    configMap, err := v1.NewConfigMap(ctx, "generator-script", &v1.ConfigMapArgs{
         // existing arguments
     }, pulumi.Parent(cmp))
+    if err != nil {
+        return nil, err
+    }
+    return configMap, nil
 })